When a base type explicitly implements a public interface method, that method is only accessible in derived types through a reference to the
current instance (namely this). If the derived type explicitly overrides that interface method, the base implementation becomes
inaccessible.
This rule raises an issue when an unsealed, externally visible type provides an explicit method implementation of a public interface
and does not provide an alternate, externally visible method with the same name.
Noncompliant code example
public interface IMyInterface
{
void MyMethod();
}
public class Foo : IMyInterface
{
void IMyInterface.MyMethod() // Noncompliant
{
MyMethod();
}
void MyMethod()
{
// Do something ...
}
}
public class Bar : Foo, IMyInterface
{
public void MyMethod()
{
// Can't access base.MyMethod()
// ((IMyInterface)this).MyMethod() would be a recursive call
}
}
Compliant solution
public interface IMyInterface
{
void MyMethod();
}
public class Foo : IMyInterface
{
void IMyInterface.MyMethod()
{
MyMethod();
}
protected void MyMethod() // or public
{
// Do something ...
}
}
public class Bar : Foo, IMyInterface
{
public void MyMethod()
{
// Do something
base.MyMethod();
}
}
Exceptions
This rule does not report a violation for an explicit implementation of IDisposable.Dispose when an externally visible
Close() or System.IDisposable.Dispose(Boolean) method is provided.
